package com.cencat.order.service;

import com.cencat.order.domain.Dispatch;
import com.cencat.order.domain.DispatchRule;
import com.cencat.order.domain.DispatchHistory;
import com.cencat.order.domain.vo.DispatchVO;
import com.cencat.order.domain.vo.DispatchStatisticsVO;
import com.cencat.order.domain.vo.DispatchAnalysisVO;
import com.cencat.order.domain.vo.DispatchOptimizationVO;
import com.cencat.order.domain.dto.SmartDispatchDTO;
import com.cencat.order.domain.dto.ManualDispatchDTO;
import com.cencat.order.domain.dto.BatchDispatchDTO;
import com.cencat.order.domain.dto.DispatchRuleDTO;
import com.baomidou.mybatisplus.extension.service.IService;

import java.util.List;
import java.util.Map;

/**
 * 智能派单服务接口
 * 
 * @author cencat
 * @date 2024-01-20
 */
public interface IDispatchService extends IService<Dispatch> {

    /**
     * 查询派单列表
     * 
     * @param dispatch 派单查询条件
     * @return 派单列表
     */
    List<Dispatch> selectDispatchList(Dispatch dispatch);

    /**
     * 获取派单详情
     * 
     * @param dispatchId 派单ID
     * @return 派单详情VO
     */
    DispatchVO getDispatchDetail(Long dispatchId);

    /**
     * 智能派单
     * 
     * @param smartDispatchDTO 智能派单DTO
     * @return 派单结果VO
     */
    DispatchVO smartDispatch(SmartDispatchDTO smartDispatchDTO);

    /**
     * 手动派单
     * 
     * @param manualDispatchDTO 手动派单DTO
     * @return 派单结果VO
     */
    DispatchVO manualDispatch(ManualDispatchDTO manualDispatchDTO);

    /**
     * 批量派单
     * 
     * @param batchDispatchDTO 批量派单DTO
     * @return 批量派单结果
     */
    List<DispatchVO> batchDispatch(BatchDispatchDTO batchDispatchDTO);

    /**
     * 重新派单
     * 
     * @param dispatchId 原派单ID
     * @param reason 重新派单原因
     * @param newDriverId 新司机ID（可选）
     * @return 新派单VO
     */
    DispatchVO redispatch(Long dispatchId, String reason, Long newDriverId);

    /**
     * 取消派单
     * 
     * @param dispatchId 派单ID
     * @param reason 取消原因
     * @return 是否成功
     */
    boolean cancelDispatch(Long dispatchId, String reason);

    /**
     * 更新派单状态
     * 
     * @param dispatchId 派单ID
     * @param status 状态
     * @param remark 备注
     * @return 是否成功
     */
    boolean updateDispatchStatus(Long dispatchId, String status, String remark);

    /**
     * 批量更新派单状态
     * 
     * @param dispatchIds 派单ID数组
     * @param status 状态
     * @param remark 备注
     * @return 是否成功
     */
    boolean batchUpdateStatus(Long[] dispatchIds, String status, String remark);

    /**
     * 司机接受派单
     * 
     * @param dispatchId 派单ID
     * @param driverId 司机ID
     * @param acceptTime 接受时间
     * @return 是否成功
     */
    boolean acceptDispatch(Long dispatchId, Long driverId, String acceptTime);

    /**
     * 司机拒绝派单
     * 
     * @param dispatchId 派单ID
     * @param driverId 司机ID
     * @param rejectReason 拒绝原因
     * @return 是否成功
     */
    boolean rejectDispatch(Long dispatchId, Long driverId, String rejectReason);

    /**
     * 派单规则管理
     */
    
    /**
     * 创建派单规则
     * 
     * @param ruleDTO 规则DTO
     * @return 规则ID
     */
    Long createDispatchRule(DispatchRuleDTO ruleDTO);

    /**
     * 更新派单规则
     * 
     * @param ruleDTO 规则DTO
     * @return 是否成功
     */
    boolean updateDispatchRule(DispatchRuleDTO ruleDTO);

    /**
     * 删除派单规则
     * 
     * @param ruleIds 规则ID数组
     * @return 是否成功
     */
    boolean deleteDispatchRules(Long[] ruleIds);

    /**
     * 获取派单规则列表
     * 
     * @param merchantId 商家ID
     * @param ruleType 规则类型
     * @return 规则列表
     */
    List<DispatchRule> getDispatchRules(Long merchantId, String ruleType);

    /**
     * 启用/禁用派单规则
     * 
     * @param ruleId 规则ID
     * @param status 状态
     * @return 是否成功
     */
    boolean updateRuleStatus(Long ruleId, String status);

    /**
     * 测试派单规则
     * 
     * @param ruleId 规则ID
     * @param testData 测试数据
     * @return 测试结果
     */
    Map<String, Object> testDispatchRule(Long ruleId, Map<String, Object> testData);

    /**
     * 派单算法优化
     */
    
    /**
     * 获取最优司机
     * 
     * @param orderId 订单ID
     * @param routeId 路线ID
     * @param deliveryType 配送类型
     * @param priority 优先级
     * @return 最优司机列表
     */
    List<Map<String, Object>> getOptimalDrivers(Long orderId, Long routeId, String deliveryType, Integer priority);

    /**
     * 计算派单得分
     * 
     * @param driverId 司机ID
     * @param orderId 订单ID
     * @param factors 评分因子
     * @return 派单得分
     */
    Double calculateDispatchScore(Long driverId, Long orderId, Map<String, Object> factors);

    /**
     * 智能路径规划
     * 
     * @param dispatchId 派单ID
     * @param optimizeType 优化类型
     * @return 路径规划结果
     */
    Map<String, Object> intelligentRouting(Long dispatchId, String optimizeType);

    /**
     * 负载均衡派单
     * 
     * @param orderIds 订单ID列表
     * @param balanceType 均衡类型
     * @return 派单结果
     */
    List<DispatchVO> loadBalanceDispatch(List<Long> orderIds, String balanceType);

    /**
     * 派单统计分析
     */
    
    /**
     * 获取派单统计信息
     * 
     * @param startDate 开始日期
     * @param endDate 结束日期
     * @param dimension 统计维度
     * @param merchantId 商家ID
     * @return 统计信息VO
     */
    DispatchStatisticsVO getDispatchStatistics(String startDate, String endDate, String dimension, Long merchantId);

    /**
     * 获取派单效率分析
     * 
     * @param startDate 开始日期
     * @param endDate 结束日期
     * @param analysisType 分析类型
     * @return 效率分析VO
     */
    DispatchAnalysisVO getDispatchEfficiency(String startDate, String endDate, String analysisType);

    /**
     * 获取司机派单统计
     * 
     * @param driverId 司机ID
     * @param startDate 开始日期
     * @param endDate 结束日期
     * @return 司机统计数据
     */
    Map<String, Object> getDriverDispatchStats(Long driverId, String startDate, String endDate);

    /**
     * 获取商家派单统计
     * 
     * @param merchantId 商家ID
     * @param startDate 开始日期
     * @param endDate 结束日期
     * @return 商家统计数据
     */
    Map<String, Object> getMerchantDispatchStats(Long merchantId, String startDate, String endDate);

    /**
     * 派单历史管理
     */
    
    /**
     * 获取派单历史
     * 
     * @param dispatchId 派单ID
     * @return 历史记录列表
     */
    List<DispatchHistory> getDispatchHistory(Long dispatchId);

    /**
     * 记录派单操作
     * 
     * @param dispatchId 派单ID
     * @param operation 操作类型
     * @param operatorId 操作人ID
     * @param remark 备注
     * @return 是否成功
     */
    boolean recordDispatchOperation(Long dispatchId, String operation, Long operatorId, String remark);

    /**
     * 派单异常处理
     */
    
    /**
     * 处理派单异常
     * 
     * @param dispatchId 派单ID
     * @param exceptionType 异常类型
     * @param exceptionDesc 异常描述
     * @param handleType 处理方式
     * @return 处理结果
     */
    Map<String, Object> handleDispatchException(Long dispatchId, String exceptionType, String exceptionDesc, String handleType);

    /**
     * 获取异常派单列表
     * 
     * @param exceptionType 异常类型
     * @param startDate 开始日期
     * @param endDate 结束日期
     * @return 异常派单列表
     */
    List<Dispatch> getExceptionDispatches(String exceptionType, String startDate, String endDate);

    /**
     * 派单实时监控
     */
    
    /**
     * 获取实时派单状态
     * 
     * @param merchantId 商家ID
     * @return 实时状态数据
     */
    Map<String, Object> getRealTimeDispatchStatus(Long merchantId);

    /**
     * 获取派单预警信息
     * 
     * @param merchantId 商家ID
     * @return 预警信息列表
     */
    List<Map<String, Object>> getDispatchAlerts(Long merchantId);

    /**
     * 设置派单预警规则
     * 
     * @param alertType 预警类型
     * @param alertRule 预警规则
     * @param merchantId 商家ID
     * @param notifyUsers 通知用户
     * @return 是否成功
     */
    boolean setDispatchAlert(String alertType, String alertRule, Long merchantId, String notifyUsers);

    /**
     * 派单性能优化
     */
    
    /**
     * 优化派单算法
     * 
     * @param optimizationType 优化类型
     * @param parameters 优化参数
     * @return 优化结果VO
     */
    DispatchOptimizationVO optimizeDispatchAlgorithm(String optimizationType, Map<String, Object> parameters);

    /**
     * 派单缓存管理
     * 
     * @param cacheType 缓存类型
     * @return 是否成功
     */
    boolean refreshDispatchCache(String cacheType);

    /**
     * 派单数据同步
     * 
     * @param syncType 同步类型
     * @param startDate 开始日期
     * @param endDate 结束日期
     * @return 是否成功
     */
    boolean syncDispatchData(String syncType, String startDate, String endDate);

    /**
     * 派单健康检查
     * 
     * @return 健康状态
     */
    Map<String, Object> dispatchHealthCheck();

    /**
     * 导入派单数据
     * 
     * @param dispatchList 派单列表
     * @return 导入结果消息
     */
    String importDispatches(List<Dispatch> dispatchList);

    /**
     * 获取派单推荐
     * 
     * @param orderId 订单ID
     * @param recommendType 推荐类型
     * @return 推荐结果
     */
    List<Map<String, Object>> getDispatchRecommendations(Long orderId, String recommendType);

    /**
     * 派单质量评估
     * 
     * @param dispatchId 派单ID
     * @param evaluationType 评估类型
     * @return 评估结果
     */
    Map<String, Object> evaluateDispatchQuality(Long dispatchId, String evaluationType);
}